home *** CD-ROM | disk | FTP | other *** search
/ Aminet 32 / Aminet 32 (1999)(Schatztruhe)[!][Aug 1999].iso / Aminet / dev / lang / Python152_Src.lha / Python152_Source / Modules / Doslibmodule.c < prev    next >
C/C++ Source or Header  |  1998-11-12  |  18KB  |  809 lines
  1.  
  2. /********************************************************************
  3.  
  4.     Lowlevel Amiga dos.library module.
  5.  
  6. -----------------------------------------------
  7.     ©1996,1997,1998 by Irmen de Jong.
  8.  
  9.     History:
  10.  
  11.      9-jun-96   Created.
  12.     13-jun-96   Added WaitSignal().
  13.     17-nov-96   Fixed empty template handling.
  14.     31-dec-96   Changed CheckSignal to look like WaitSignal.
  15.     18-jan-98   Updated for Python 1.5
  16.     27-sep-98    Added some extra functions.
  17.     12-nov-98    Renamed `doslib' to `Doslib'
  18.  
  19. Module members:
  20.  
  21.     error       -- Exeption string object.  ('Doslib.error')
  22.     ReadArgs    -- dos.library/ReadArgs function.
  23.                    result=Doslib.ReadArgs(template,args,types)
  24.  
  25.     WaitSignal  -- generic Wait() function, like select. Waits for certain
  26.                    signals to occur.
  27.                    (sigs,objlist) = WaitSignal(args)
  28.                    args = integer, object, or list of ints/objects.
  29.                    integers are sigmask values. Objects must have 'signal'
  30.                    attribute to get this value.
  31.  
  32.     CheckSignal -- Like Wait() but DOES NOT WAIT FOR THE SIGNALS:
  33.                    merely checks if certain signals are set.
  34.  
  35.     CompareDates, DateStamp, DateToStr, StrToDate, Fault,
  36.     IoErr, SetIoErr, IsFileSystem, Relabel, SetProtection,
  37.     SetComment, Examine, Inhibit, SetFileDate, SetOwner, Info,
  38.     GetProgramDir, GetProgramName: 
  39.         just like the original dos.library calls.
  40.  
  41.     DS2time     -- convert DateStamp tuple to time() value (see time module)
  42.     time2DS     -- convert time() value to DateStamp tuple (see time module)
  43.  
  44.  
  45. **************************************************************************/
  46.  
  47. #include <stdlib.h>
  48. #include <exec/types.h>
  49. #include <exec/memory.h>
  50. #include <dos/dos.h>
  51. #include <dos/datetime.h>
  52. #include <dos/rdargs.h>
  53. #include <proto/dos.h>
  54. #include <proto/exec.h>
  55. #include "Python.h"
  56.  
  57.  
  58. static PyObject *error;    // Exception
  59.  
  60.  
  61. /* Convenience; sets error with IoError() string, return NULL */
  62. /* If ok, return Py_NONE */
  63. static PyObject *check_ok(BOOL ok)
  64. {
  65.     char buf[100];
  66.     if(ok)
  67.     {
  68.         Py_INCREF(Py_None);
  69.         return Py_None;
  70.     }
  71.  
  72.     Fault(IoErr(),NULL,buf,100);
  73.     PyErr_SetString(error,buf);
  74.     return NULL;
  75. }
  76.  
  77.  
  78. /************** MODULE FUNCTIONS *******************/
  79.  
  80. static PyObject *
  81. Doslib_ReadArgs(PyObject *self, PyObject *arg)
  82. {
  83.     char *template;
  84.     char *args;
  85.     PyObject *types;        // the keywords & their types (tuple of tuples)
  86.  
  87.     PyObject *result=NULL;
  88.  
  89.     LONG *argarray;
  90.     int num_args;
  91.     BOOL free_args=FALSE;
  92.     
  93.     if (!PyArg_ParseTuple(arg, "ssO!", &template, &args,
  94.         &PyTuple_Type,&types))
  95.         return NULL;
  96.  
  97.     if(PyTuple_Size(types)>0 || strlen(template)>0)
  98.     {
  99.         /* check argument count */
  100.         char *t=template;
  101.         num_args=1;
  102.         while(*t)
  103.         {
  104.             if(*t++ == ',') num_args++;
  105.         }
  106.         if(num_args!=PyTuple_Size(types))
  107.         {
  108.             PyErr_SetString(PyExc_ValueError,"types length does not match template");
  109.             return NULL;
  110.         }
  111.     }
  112.     else
  113.     {
  114.         /* template is empty string; no arguments expected */
  115.         if(strlen(stpblk(args))>0)
  116.         {
  117.             SetIoErr(ERROR_TOO_MANY_ARGS);
  118.             return check_ok(FALSE);
  119.         }
  120.         return PyDict_New();        // empty result dictionary
  121.     }
  122.  
  123.     if(argarray=calloc(sizeof(LONG),num_args))
  124.     {
  125.         struct RDArgs *rdargs;
  126.         int arglen=strlen(args);
  127.  
  128.         if((arglen==0) || (args[arglen-1]!='\n'))
  129.         {
  130.             char *t = malloc(arglen+2);
  131.             if(t)
  132.             {
  133.                 strcpy(t,args); t[arglen++]='\n'; t[arglen]=0;  // add \n !!!
  134.                 args=t; free_args=TRUE;
  135.             }
  136.             else
  137.             {
  138.                 free(argarray);
  139.                 return PyErr_NoMemory();
  140.             }
  141.         }
  142.  
  143.         if(rdargs = AllocDosObject(DOS_RDARGS, NULL))
  144.         {
  145.             rdargs->RDA_Flags = RDAF_NOPROMPT;
  146.             rdargs->RDA_Source.CS_Buffer = args;
  147.             rdargs->RDA_Source.CS_Length = arglen;
  148.             rdargs->RDA_Source.CS_CurChr = 0;
  149.             rdargs->RDA_DAList = NULL;
  150.             rdargs->RDA_Buffer = NULL;
  151.  
  152.             if( !ReadArgs(template, argarray, rdargs) )
  153.             {
  154.                 (void)check_ok(FALSE);
  155.             }
  156.             else
  157.             {
  158.                 if(result=PyDict_New())
  159.                 {
  160.                     /************
  161.                     Traverse the types tuple and for each argument,
  162.                     extract it's value. types consists of tuples (k,t) where:
  163.                     k=keyword;
  164.                     t=the keyword's type:
  165.                         'X'     - string
  166.                         'S','T' - bool (integer)   !!! T not yet supported 
  167.                         'N'     - integer
  168.                         'A'     - array of strings
  169.                         'I'     - array of ints
  170.                     ***********/
  171.  
  172.                     PyObject *tup, *val;
  173.                     BOOL result_ok=TRUE;
  174.                     int cnt=0;
  175.                     while (result_ok && (tup=PyTuple_GetItem(types, cnt)))
  176.                     {
  177.                         PyObject *keyword, *type;
  178.                         char *type_c;
  179.  
  180.                         if(PyTuple_Size(tup)!=2)
  181.                         {
  182.                             PyErr_SetString(PyExc_ValueError,"types tuple invalid");
  183.                             result_ok=FALSE; break;
  184.                         }
  185.  
  186.                         keyword=PyTuple_GetItem(tup,0);
  187.                         type=PyTuple_GetItem(tup,1);
  188.  
  189.                         result_ok=FALSE;
  190.                         type_c=PyString_AsString(type);
  191.                         if(type_c==NULL)
  192.                         {
  193.                             result_ok=FALSE; break; /* no string!? */
  194.                         }
  195.  
  196.                         switch (type_c[0]) {
  197.                         case 'S':       // boolean switch
  198.                             if(val=PyInt_FromLong(argarray[cnt]))
  199.                             {
  200.                                 result_ok=(0==PyDict_SetItem(result,keyword,val));
  201.                                 Py_DECREF(val);
  202.                             }
  203.                             break;
  204.                         case 'N':       // number
  205.                             if(argarray[cnt])
  206.                             {
  207.                                 if(val=PyInt_FromLong(*(LONG*)argarray[cnt]))
  208.                                 {
  209.                                     result_ok=(0==PyDict_SetItem(result,keyword,val));
  210.                                     Py_DECREF(val);
  211.                                 }
  212.                             }
  213.                             else result_ok=(0==PyDict_SetItem(result,keyword,Py_None));
  214.                             break;
  215.                         case 'X':       // string
  216.                             if(argarray[cnt])
  217.                             {
  218.                                 if(val=PyString_FromString((STRPTR)argarray[cnt]))
  219.                                 {
  220.                                     result_ok=(0==PyDict_SetItem(result,keyword,val));
  221.                                     Py_DECREF(val);
  222.                                 }
  223.                             }
  224.                             else result_ok=(0==PyDict_SetItem(result,keyword,Py_None));
  225.                             break;
  226.                         case 'A':       // array of strings
  227.                         case 'I':       // array of numbers
  228.                             if(val=PyList_New(0))
  229.                             {
  230.                                 if(argarray[cnt])
  231.                                 {
  232.                                     if(type_c[0]=='A')
  233.                                     {
  234.                                         char **str = (char**)argarray[cnt];
  235.                                         PyObject *so;
  236.                                         /* build the string list */
  237.                                         while(*str)
  238.                                         {
  239.                                             if(so=PyString_FromString(*str))
  240.                                             {
  241.                                                 if(!(result_ok=(0==PyList_Append(val,so))))
  242.                                                     break;
  243.                                                 Py_DECREF(so);
  244.                                             }
  245.                                             else break;
  246.                                             str++;
  247.                                         }
  248.                                     }
  249.                                     else /* array of numbers */
  250.                                     {
  251.                                         int **ia = (int**)argarray[cnt];
  252.                                         PyObject *io;
  253.                                         /* build the integer list */
  254.                                         while(*ia)
  255.                                         {
  256.                                             if(io=PyInt_FromLong(**ia))
  257.                                             {
  258.                                                 if(!(result_ok=(0==PyList_Append(val,io))))
  259.                                                     break;
  260.                                                 Py_DECREF(io);
  261.                                             }
  262.                                             else break;
  263.                                             ia++;
  264.                                         }
  265.                                     }
  266.                                     result_ok=result_ok&&(0==PyDict_SetItem(result,keyword,val));
  267.                                 }
  268.                                 else
  269.                                 {
  270.                                     // insert the empty list.
  271.                                     result_ok=(0==PyDict_SetItem(result,keyword,val));
  272.                                 }
  273.                                 Py_DECREF(val);
  274.                             }
  275.                             break;
  276.                         default:
  277.                             PyErr_SetString(PyExc_ValueError,"illegal arg type");
  278.                             break;
  279.                         }
  280.                         cnt++;
  281.                     }
  282.                     if(!result_ok)
  283.                     {
  284.                         Py_DECREF(result);
  285.                         result=0;
  286.                     }
  287.                 }
  288.             }
  289.  
  290.             FreeArgs(rdargs);
  291.             FreeDosObject( DOS_RDARGS, rdargs );
  292.         }
  293.         else (void)PyErr_NoMemory();
  294.  
  295.         if(free_args) free(args);
  296.         free(argarray);
  297.     }
  298.     else (void)PyErr_NoMemory();
  299.  
  300.     return (PyObject*)result;
  301. }
  302.  
  303.  
  304. static PyObject *
  305. CheckOrWaitSignal(PyObject *self, PyObject *arg, BOOL doWait)
  306. {
  307.     struct {
  308.         PyObject *ob;       // the object, NULL means: only sigmask value
  309.         ULONG sigmask;
  310.     } objs[32];
  311.     int i,listsize = 0;
  312.     PyObject *argo, *result;
  313.     ULONG signal;
  314.  
  315.     if(!PyArg_ParseTuple(arg,"O",&argo)) return NULL;
  316.  
  317.     if(PyInt_Check(argo))
  318.     {
  319.         /* 1 int arg */
  320.         signal=PyInt_AsLong(argo);
  321.         objs[0].ob=NULL;
  322.         objs[0].sigmask=signal;
  323.         listsize++;
  324.     }
  325.     else if(PyList_Check(argo))
  326.     {
  327.         /* 1 list arg */
  328.         int len=PyList_Size(argo);
  329.  
  330.         if(len==0 || len>32)
  331.         {
  332.             PyErr_SetString(PyExc_ValueError,"list size must be 1..32");
  333.             return NULL;
  334.         }
  335.  
  336.         signal = 0;
  337.  
  338.         for(i=0;i<len;i++)
  339.         {
  340.             PyObject *attr;
  341.             PyObject *item = PyList_GetItem(argo,i);
  342.             ULONG s;
  343.  
  344.             if(PyInt_Check(item))
  345.             {
  346.                 s = PyInt_AsLong(item);
  347.                 objs[listsize].ob = NULL;
  348.                 objs[listsize++].sigmask=s;
  349.                 signal |= s;
  350.             }
  351.             else if(attr = PyObject_GetAttrString(item,"signal"))
  352.             {
  353.                 ULONG s = PyInt_AsLong(attr);
  354.  
  355.                 if((s==-1) && PyErr_Occurred())
  356.                 {
  357.                     Py_DECREF(attr);
  358.                     return NULL;
  359.                 }
  360.                 
  361.                 signal |= s;
  362.                 objs[listsize].ob=item;
  363.                 objs[listsize++].sigmask=s;
  364.             }
  365.             else return (PyObject*)PyErr_BadArgument();
  366.         }
  367.     }
  368.     else
  369.     {
  370.         /* other, try signal attribute */
  371.         PyObject *attr;
  372.         if(attr=PyObject_GetAttrString(argo,"signal"))
  373.         {
  374.             /* Found! */
  375.             signal = PyInt_AsLong(attr);
  376.  
  377.             if((signal==-1) && PyErr_Occurred())
  378.             {
  379.                 Py_DECREF(attr);
  380.                 return NULL;
  381.             }
  382.  
  383.             objs[0].ob = attr;
  384.             objs[0].sigmask = signal;
  385.             listsize++;
  386.         }
  387.         else return NULL;
  388.     }
  389.     
  390.     if(doWait)
  391.         signal = Wait(signal);
  392.     else
  393.         signal = CheckSignal(signal);
  394.  
  395.     if(result=PyList_New(0))
  396.     {
  397.         PyObject *tup;
  398.  
  399.         for(i=0;i<listsize;i++)
  400.         {
  401.             if(objs[i].ob && (signal&objs[i].sigmask))
  402.             {
  403.                 if(0!=PyList_Append(result,objs[i].ob))
  404.                 {
  405.                     Py_DECREF(result);
  406.                     return NULL;
  407.                 }
  408.             }
  409.         }
  410.  
  411.         tup=Py_BuildValue("(iO)",signal,result);
  412.         Py_DECREF(result);
  413.         return tup;
  414.     }
  415.     else return NULL;
  416. }
  417.  
  418. static PyObject *
  419. Doslib_WaitSignal(PyObject *self, PyObject *arg)
  420. {
  421.     return CheckOrWaitSignal(self,arg,TRUE);
  422. }
  423.  
  424. static PyObject *
  425. Doslib_CheckSignal(PyObject *self, PyObject *arg)
  426. {
  427.     return CheckOrWaitSignal(self,arg,FALSE);
  428. }
  429.  
  430.  
  431. static PyObject *
  432. Doslib_DateToStr(PyObject *self, PyObject *arg)
  433. {
  434.     // (datestamp[,format=FORMAT_DOS,flags=0]) -> string
  435.  
  436.     struct DateTime dt;
  437.     PyObject *ds_t;
  438.     int flags=0,format=FORMAT_DOS;
  439.     char day[32];
  440.     char date[32];
  441.     char time[32];
  442.  
  443.     if(!PyArg_ParseTuple(arg,"O!|ii",&PyTuple_Type,&ds_t,&format,&flags)) return NULL;
  444.  
  445.     if(!PyArg_ParseTuple(ds_t,"iii;invalid datestamp tuple",
  446.         &dt.dat_Stamp.ds_Days,&dt.dat_Stamp.ds_Minute,&dt.dat_Stamp.ds_Tick)) return NULL;
  447.  
  448.     dt.dat_StrDay=day;
  449.     dt.dat_StrDate=date;
  450.     dt.dat_StrTime=time;
  451.     dt.dat_Flags=flags;
  452.     dt.dat_Format=format;
  453.     DateToStr(&dt);
  454.     return Py_BuildValue("(sss)",dt.dat_StrDay,dt.dat_StrDate,dt.dat_StrTime);  
  455. }
  456.  
  457. static PyObject *
  458. Doslib_StrToDate(PyObject *self, PyObject *arg)
  459. {
  460.     // (datestring[,timestring,format=FORMAT_DOS,flags=0]) -> datestamp
  461.  
  462.     struct DateTime dt;
  463.     
  464.     char *date;
  465.     char *time=NULL;
  466.     int flags=0,format=FORMAT_DOS;
  467.  
  468.     if(!PyArg_ParseTuple(arg,"s|sii",&date,&time,&format,&flags)) return NULL;
  469.  
  470.     memset(&dt,0,sizeof(dt));
  471.     dt.dat_StrDate=date;
  472.     dt.dat_StrTime=time;
  473.     dt.dat_Flags=flags;
  474.     dt.dat_Format=format;
  475.     StrToDate(&dt);
  476.     return Py_BuildValue("(iii)",dt.dat_Stamp.ds_Days,dt.dat_Stamp.ds_Minute,dt.dat_Stamp.ds_Tick);
  477. }
  478.  
  479. static PyObject *
  480. Doslib_CompareDates(PyObject *self, PyObject *arg)      // (ds1, ds2) -> <0,0,>0
  481. {
  482.     PyObject *ds_t1, *ds_t2;
  483.     struct DateStamp ds1,ds2;
  484.  
  485.     if(!PyArg_ParseTuple(arg,"O!O!",
  486.         &PyTuple_Type,&ds_t1,&PyTuple_Type,&ds_t2)) return NULL;
  487.  
  488.     if(!PyArg_ParseTuple(ds_t1,"iii;invalid datestamp tuple",&ds1.ds_Days,&ds1.ds_Minute,&ds1.ds_Tick)) return NULL;
  489.     if(!PyArg_ParseTuple(ds_t2,"iii;invalid datestamp tuple",&ds2.ds_Days,&ds2.ds_Minute,&ds2.ds_Tick)) return NULL;
  490.  
  491.     return PyInt_FromLong(CompareDates(&ds1,&ds2)); 
  492. }
  493.  
  494. static PyObject *
  495. Doslib_DateStamp(PyObject *self, PyObject *arg)     // () -> datestamp
  496. {
  497.     struct DateStamp ds;
  498.     if(!PyArg_NoArgs(arg)) return NULL;
  499.     
  500.     DateStamp(&ds);
  501.     return Py_BuildValue("(iii)",ds.ds_Days,ds.ds_Minute,ds.ds_Tick);
  502. }
  503.  
  504. static PyObject *
  505. Doslib_Info(PyObject *self, PyObject *arg)     // (name) -> infoblock
  506. {
  507.     struct InfoData *_id;
  508.     char *name;
  509.  
  510.     if(!PyArg_ParseTuple(arg,"s",&name)) return NULL;
  511.     if(_id=AllocVec(sizeof(struct InfoData),MEMF_PUBLIC))
  512.     {
  513.         BPTR lock;
  514.         if(lock=Lock(name, SHARED_LOCK))
  515.         {
  516.             if(Info(lock,_id))
  517.             {
  518.                 struct InfoData id;
  519.                 id = *_id;
  520.                 FreeVec(_id);
  521.                 UnLock(lock);
  522.                 return Py_BuildValue("(iiiiiiii)", id.id_NumSoftErrors, id.id_UnitNumber,
  523.                     id.id_DiskState, id.id_NumBlocks, id.id_NumBlocksUsed, id.id_BytesPerBlock,
  524.                     id.id_DiskType, id.id_InUse);
  525.             }
  526.             else
  527.             {
  528.                 (void) check_ok(FALSE);
  529.             }
  530.             FreeVec(_id);
  531.             UnLock(lock);
  532.         }
  533.         else
  534.         {
  535.             (void) check_ok(FALSE);
  536.         }
  537.         return NULL;
  538.     }
  539.     return PyErr_NoMemory();
  540. }
  541.  
  542. static PyObject *
  543. Doslib_Fault(PyObject *self, PyObject *arg)         // (errnum[, header]) -> string
  544. {
  545.     int errnum;
  546.     char *header=NULL;
  547.     char buf[100];
  548.  
  549.     if(!PyArg_ParseTuple(arg,"i|s",&errnum,&header)) return NULL;
  550.     Fault(errnum,header,buf,100);
  551.     return PyString_FromString(buf);
  552. }
  553.  
  554. static PyObject *
  555. Doslib_GetProgramDir(PyObject *self, PyObject *arg) // () -> string
  556. {
  557.     BPTR lock;
  558.     if(!PyArg_NoArgs(arg)) return NULL;
  559.     
  560.     if(lock=GetProgramDir())
  561.     {
  562.         char name[256];
  563.         if(NameFromLock(lock, name, 256))
  564.         {
  565.             return PyString_FromString(name);
  566.         }
  567.         return check_ok(FALSE);
  568.     }
  569.     return PyString_FromString("");
  570. }
  571.  
  572. static PyObject *
  573. Doslib_GetProgramName(PyObject *self, PyObject *arg) // () -> string
  574. {
  575.     char name[256];
  576.     if(!PyArg_NoArgs(arg)) return NULL;
  577.     
  578.     if(GetProgramName(name, 256))
  579.     {
  580.         return PyString_FromString(name);
  581.     }
  582.     return check_ok(FALSE);
  583. }
  584.  
  585. static PyObject *
  586. Doslib_IoErr(PyObject *self, PyObject *arg)         // () -> int
  587. {
  588.     if(!PyArg_NoArgs(arg)) return NULL;
  589.     return PyInt_FromLong(IoErr());
  590. }
  591.  
  592. static PyObject *
  593. Doslib_Inhibit(PyObject *self, PyObject *arg) // (drive [,switch]) -> bool
  594. {
  595.     char *name;
  596.     int swtch=1;
  597.  
  598.     if(!PyArg_ParseTuple(arg,"s|i",&name,&swtch)) return NULL;
  599.  
  600.     return check_ok(Inhibit(name,swtch));
  601. }
  602.  
  603. static PyObject *
  604. Doslib_SetIoErr(PyObject *self, PyObject *arg)      // (int) -> int
  605. {
  606.     int errnum;
  607.  
  608.     if(!PyArg_ParseTuple(arg,"i",&errnum)) return NULL;
  609.     return PyInt_FromLong(SetIoErr(errnum));
  610. }
  611.  
  612. static PyObject *
  613. Doslib_IsFileSystem(PyObject *self, PyObject *arg)      // (string) -> bool
  614. {
  615.     char *name;
  616.  
  617.     if(!PyArg_ParseTuple(arg,"s",&name)) return NULL;
  618.     return PyInt_FromLong(IsFileSystem(name));
  619. }
  620.  
  621. static PyObject *
  622. Doslib_Relabel(PyObject *self, PyObject *arg)   // (oldvolname, newvolname)
  623. {
  624.     char *old, *new;
  625.  
  626.     if(!PyArg_ParseTuple(arg,"ss",&old,&new)) return NULL;
  627.     if(old[strlen(old)-1]!=':')
  628.     {
  629.         PyErr_SetString(PyExc_ValueError,"volume name must end with :");
  630.         return NULL;
  631.     }
  632.     if(new[strlen(new)-1]==':')
  633.     {
  634.         PyErr_SetString(PyExc_ValueError,"new name must not end with :");
  635.         return NULL;
  636.     }
  637.     return check_ok(Relabel(old,new));
  638. }
  639.  
  640. static PyObject *
  641. Doslib_SetProtection(PyObject *self, PyObject *arg) // (file,protbits) -> bool
  642. {
  643.     char *name;
  644.     int pb;
  645.  
  646.     if(!PyArg_ParseTuple(arg,"si",&name,&pb)) return NULL;
  647.  
  648.     return check_ok(SetProtection(name,pb));
  649. }
  650.  
  651. static PyObject *
  652. Doslib_SetFileDate(PyObject *self, PyObject *arg) // (file,datestamp) -> bool
  653. {
  654.     struct DateStamp ds;
  655.     PyObject *ds_t;
  656.     char *name;
  657.  
  658.     if(!PyArg_ParseTuple(arg,"sO!",&name,&PyTuple_Type,&ds_t)) return NULL;
  659.  
  660.     if(!PyArg_ParseTuple(ds_t,"iii;invalid datestamp tuple",
  661.         &ds.ds_Days,&ds.ds_Minute,&ds.ds_Tick)) return NULL;
  662.  
  663.     return check_ok(SetFileDate(name,&ds));
  664. }
  665.  
  666. static PyObject *
  667. Doslib_Examine(PyObject *self, PyObject *arg)       // (filename) -> fib structure
  668. {
  669.     char *name;
  670.     BPTR lock;
  671.     struct FileInfoBlock __aligned fib;
  672.  
  673.     if(!PyArg_ParseTuple(arg,"s",&name)) return NULL;
  674.     if(lock=Lock(name,ACCESS_READ))
  675.     {
  676.         if(Examine(lock,&fib))
  677.         {
  678.             UnLock(lock);
  679.             return Py_BuildValue("(siiiii(iii)sii)",
  680.                 fib.fib_FileName,
  681.                 fib.fib_Size,
  682.                 fib.fib_DirEntryType,
  683.                 fib.fib_Protection,
  684.                 fib.fib_DiskKey,
  685.                 fib.fib_NumBlocks,
  686.                 fib.fib_Date.ds_Days, fib.fib_Date.ds_Minute, fib.fib_Date.ds_Tick,
  687.                 fib.fib_Comment,
  688.                 fib.fib_OwnerUID,
  689.                 fib.fib_OwnerGID);
  690. /******************
  691.             return Py_BuildValue("(iisiiii(iii)sii)",
  692.                 fib.fib_DiskKey,
  693.                 fib.fib_DirEntryType,
  694.                 fib.fib_FileName,
  695.                 fib.fib_Protection,
  696.                 fib.fib_EntryType,
  697.                 fib.fib_Size,
  698.                 fib.fib_NumBlocks,
  699.                 fib.fib_Date.ds_Days, fib.fib_Date.ds_Minute, fib.fib_Date.ds_Tick,
  700.                 fib.fib_Comment,
  701.                 fib.fib_OwnerUID,
  702.                 fib.fib_OwnerGID);
  703. ******************/
  704.         }
  705.         UnLock(lock);
  706.     }
  707.     return check_ok(FALSE);
  708. }
  709.  
  710. static PyObject *
  711. Doslib_SetComment(PyObject *self, PyObject *args)    // (file,comment) -> bool
  712. {
  713.     char *path, *note;
  714.  
  715.     if (!PyArg_ParseTuple(args, "ss", &path,¬e)) return NULL;
  716.     return check_ok(SetComment(path,note));
  717. }
  718.  
  719. static PyObject *
  720. Doslib_SetOwner(PyObject *self, PyObject *args)        // (file, uid, gid) -> bool
  721. {
  722.     char *file;
  723.     int uid, gid;
  724.     LONG guid;
  725.  
  726.     if (!PyArg_ParseTuple(args, "sii", &file,&uid,&gid)) return NULL;
  727.     guid = ((uid&0xFFFF)<<16) | (gid&0xFFFF);
  728.     return check_ok(SetOwner(file,guid));
  729. }
  730.  
  731.  
  732. /* the offset between DateStamp() and time() epoch: */
  733. #define TIME_OFFSET 252457200.0
  734.  
  735. static PyObject *
  736. Doslib_DS2time(PyObject *self, PyObject *args)
  737. {
  738.     struct DateStamp ds;
  739.  
  740.     if(!PyArg_ParseTuple(args,"(iii)",&ds.ds_Days,&ds.ds_Minute,&ds.ds_Tick)) return NULL;
  741.  
  742.     return PyFloat_FromDouble(
  743.         86400.0*ds.ds_Days + 60.0*ds.ds_Minute + ((double)ds.ds_Tick/50.0) + TIME_OFFSET
  744.     );
  745. }
  746.  
  747. static PyObject *
  748. Doslib_time2DS(PyObject *self, PyObject *args)
  749. {
  750.     double t;
  751.     int days,minutes,ticks;
  752.  
  753.     if(!PyArg_ParseTuple(args,"d",&t)) return NULL;
  754.  
  755.     t -= TIME_OFFSET;
  756.     days =  t / 86400.0;
  757.     t -= days*86400.0;
  758.     minutes = t / 60.0;
  759.     t -= minutes*60.0;
  760.     ticks = t*50.0;
  761.  
  762.     return Py_BuildValue("(iii)",days,minutes,ticks);
  763. }
  764.  
  765.  
  766.  
  767. /*** FUNCTIONS FROM THE MODULE ***/
  768.  
  769. static struct PyMethodDef Doslib_global_methods[] = {
  770.     {"ReadArgs", Doslib_ReadArgs, 1},
  771.     {"WaitSignal", Doslib_WaitSignal, 1},
  772.     {"CheckSignal", Doslib_CheckSignal, 1},
  773.     {"CompareDates", Doslib_CompareDates, 1},
  774.     {"DateStamp", Doslib_DateStamp, 0},
  775.     {"DateToStr", Doslib_DateToStr, 1},
  776.     {"StrToDate", Doslib_StrToDate, 1},
  777.     {"Fault", Doslib_Fault, 1},
  778.     {"GetProgramDir", Doslib_GetProgramDir, 0},
  779.     {"GetProgramName", Doslib_GetProgramName, 0},
  780.     {"Inhibit", Doslib_Inhibit, 1},
  781.     {"Info", Doslib_Info, 1},
  782.     {"IoErr", Doslib_IoErr, 0},
  783.     {"SetIoErr", Doslib_SetIoErr, 1},
  784.     {"IsFileSystem", Doslib_IsFileSystem, 1},
  785.     {"Relabel", Doslib_Relabel, 1},
  786.     {"SetProtection", Doslib_SetProtection, 1},
  787.     {"SetComment", Doslib_SetComment, 1},
  788.     {"SetFileDate", Doslib_SetFileDate, 1},
  789.     {"SetOwner", Doslib_SetOwner, 1},
  790.     {"Examine", Doslib_Examine, 1},
  791.     {"DS2time", Doslib_DS2time, 1},
  792.     {"time2DS", Doslib_time2DS, 1},
  793.     {NULL,      NULL}       /* sentinel */
  794. };
  795.  
  796. void
  797. initDoslib Py_PROTO((void))
  798. {
  799.     PyObject *m, *d;
  800.  
  801.     m = Py_InitModule("Doslib", Doslib_global_methods);
  802.     d = PyModule_GetDict(m);
  803.  
  804.     /* Initialize error exception */
  805.     error = PyErr_NewException("Doslib.error", NULL, NULL);
  806.     if (error != NULL)
  807.         PyDict_SetItemString(d, "error", error);
  808. }
  809.